ADC.c

Go to the documentation of this file.

#include "Compile_Options.h"
#include "derivative.h"
#include "ADC.h"
#include <limits.h>
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
const ADC_t catADCInstanceList[] = 
{
  &ADC_0, &ADC_1
};
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
uint16_t* gpu16ADCResults[(ADC_NO_MODULES * (ADC_CH_MAX + 1u))];
uint16_t gau16ADCChToRead[ADC_NO_MODULES];

/*
 ******************************************************************************
 * Function : u8fnADCConvert()
 ******************************************************************************
 */
uint8_t u8fnADCConvert(const uint8_t cu8ADCInstance,
                             const uint8_t cu8ADCCh, uint16_t* pu16Result)
{
  uint8_t u8Status;
  ADCChConfig_t tADCChConfig;
  
  /* Disable any on-going ADC conversion */
  u8Status = u8fnADCNormalConversionEnable(cu8ADCInstance, CLEAR);
  if(CLEAR == u8Status)
  {
    /* Configure ADC channel */
    tADCChConfig.P.ChIsrEn = TRUE;
    tADCChConfig.P.ChDMAEn = CLEAR;
    tADCChConfig.P.Instance = cu8ADCInstance;
    tADCChConfig.P.Channel = cu8ADCCh;
    u8Status = u8fnADCChannelConfig(&tADCChConfig, pu16Result);
    
    if(CLEAR == u8Status)
    {
      /* Trigger a conversion */
      u8Status = u8fnADCNormalConversionEnable(cu8ADCInstance, TRUE);
      /* We'll exit now. Result shall be ready when ADC is done. */
      /* If the ADC is in SCAN mode, no need to redo this */
    }
  }
  else
  {
    /* In this particular case, status is already set to something. */
  }
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnADCConfig
 ******************************************************************************
 */
uint8_t u8fnADCConfig(uint8_t u8Instance, ADCConfig_t* ptADCConfig)
{
  /* Declare local variables */
  uint8_t u8Status;
  ADC_t tMyADC;
  
  /* Init local variables */
  u8Status = CLEAR;
  tMyADC = catADCInstanceList[u8Instance];
  
  /* Verify that the selected instance is valid */
  if (CLEAR != tMyADC)
  {
    /* Clear any previous settings to go read a particular channel */
    gau16ADCChToRead[u8Instance] = CLEAR;
    
    /* Force any ongoing operation to stop */
    tMyADC->MCR.B.NSTART = CLEAR;
    
    /* Force the ADC into low power mode */
    tMyADC->MCR.B.PWDN = TRUE;
    
    /* Configure according to passed parameter tADCConfig */
    /* Start with general config */
    /* Enable or disable an existing result to be overwritten */
    tMyADC->MCR.B.OWREN = ptADCConfig->P.OverWriteEn;
    /* Choose which alignment will be used */
    tMyADC->MCR.B.WLSIDE = ptADCConfig->P.LeftAligned;
    /* Select between one-shot and scan modes */
    tMyADC->MCR.B.MODE = ptADCConfig->P.ScanModeEn;
    /* Enable or disable the Cross-triggering unit */
    tMyADC->MCR.B.CTUEN = ptADCConfig->P.CTUEn;
    /* Enable or disable the power-saving auto-clock shut-off */
    tMyADC->MCR.B.ACK0 = ptADCConfig->P.AutoClockEn;
    /* Select clocking speed (divide by half or not */
    tMyADC->MCR.B.ADCLKSEL = ptADCConfig->P.ClkSel;
    
    /* Also enable corresponding Isrs */
    tMyADC->IMR.B.MSKEOCTU = ptADCConfig->P.EOCTUIsrEn;
    tMyADC->IMR.B.MSKJEOC = ptADCConfig->P.JEOCIsrEn;
    tMyADC->IMR.B.MSKJECH = ptADCConfig->P.JEOCHIsrEn;
    tMyADC->IMR.B.MSKEOC = ptADCConfig->P.EOCIsrEn;
    tMyADC->IMR.B.MSKECH = ptADCConfig->P.EOCHIsrEn;
    /* If necessary, enable DMAs and define how they will be cleared */
    tMyADC->DMAE.B.DCLR = ptADCConfig->P.DMAClrOnRead;
    tMyADC->DMAE.B.DMAEN = ptADCConfig->P.DMAEn;
    
    /* Next, configure sampling speed for high-resolution channels   */
    /* Note that extended channels are not configured at all because */
    /* Pictus only uses these channels.                              */
    tMyADC->CTR[CLEAR].R = (uint32_t) (ptADCConfig->R.CTR);
    
    /* Force the ADC into idle mode */
    tMyADC->MCR.B.PWDN = CLEAR;
  }
  else
  {
    u8Status = ADC_ERR_BAD_INSTANCE;
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnADCSelectRegIndex
 ******************************************************************************
 */
static uint8_t u8fnADCSelectRegIndex(uint8_t u8Channel, uint16_t* pu16Mask)
{
  *pu16Mask = (uint16_t)(BIT0 << (u8Channel % BITS_IN_32));
  
  return (u8Channel / BITS_IN_32);
}
/*
 ******************************************************************************
 * u8fnADCChannelConfig
 ******************************************************************************
 */
uint8_t u8fnADCChannelConfig(const ADCChConfig_t* tADCChConfig,
    const uint16_t* pu16Results)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint16_t u16ChRegMask;
  uint8_t u8ChRegIndex;
  ADC_t tMyADC;
  
  /* Init local variables */
  u8Status = CLEAR;
  tMyADC = catADCInstanceList[(uint8_t) tADCChConfig->P.Instance];
  
  if(N_ELEMENTS(catADCInstanceList) > (uint8_t)tADCChConfig->P.Instance)
  {
    /* Make sure that the passed channel is a valid one */
    if (ADC_CH_MAX >= tADCChConfig->P.Channel)
    {
      /* Make sure that there's no on-going conversion */
      if (CLEAR == (ADC_ST_SAMPLE & tMyADC->MSR.B.ADCSTATUS))
      {
        /* Make sure the module is not in low power mode - force it ON */
        tMyADC->MCR.B.PWDN = CLEAR;
        
        /* Figure out what the mask is for this particular channel */
        u8ChRegIndex = u8fnADCSelectRegIndex(
            (uint8_t)tADCChConfig->P.Channel, (uint16_t*)&u16ChRegMask);
        
        /* Enable this channel */
        tMyADC->NCMR[u8ChRegIndex].R |= u16ChRegMask;
        
        /* Now take care of ISR according to settings */
        if (TRUE == tADCChConfig->P.ChIsrEn)
        {
          tMyADC->CIMR[u8ChRegIndex].R |= u16ChRegMask;
          /* Point the result to the right location */
          gpu16ADCResults[((uint8_t) tADCChConfig->P.Instance * (ADC_CH_MAX
              + 1u)) + tADCChConfig->P.Channel] = (uint16_t*)pu16Results;
        }
        else
        {
          tMyADC->CIMR[u8ChRegIndex].R &= ~u16ChRegMask;
        }
        
        /* Same thing for DMA */
        if (TRUE == tADCChConfig->P.ChDMAEn)
        {
          tMyADC->DMAR[u8ChRegIndex].R |= u16ChRegMask;
        }
        else
        {
          tMyADC->DMAR[u8ChRegIndex].R &= ~u16ChRegMask;
          
          /* If DMA is not enabled, it is a good idea to remember */
          /* that we're supposed to be reading it in case CIMR is */
          /* not set. We will do so next.                         */
          gau16ADCChToRead[(uint8_t)tADCChConfig->P.Instance]
              |= u16ChRegMask;
        }
      }
      else
      {
        u8Status = ADC_ERR_ONGOING_CONV;
      }
    }
    else
    {
      u8Status = ADC_ERR_INVALID_CH;
    }
  }
  else
  {
    u8Status = ADC_ERR_BAD_INSTANCE;
  }
  
  return (u8Status);
}

/*
 ******************************************************************************
 * u8fnADCReadChannel
 ******************************************************************************
 */
uint8_t u8fnADCReadChannel(uint8_t u8Instance, uint8_t u8Channel,
    uint16_t* pu16ADCResult)
{
  /* Declare local variables */
  uint8_t u8Status;
  ADC_t tMyADC;
  
  /* Init local variables */
  u8Status = CLEAR;
  tMyADC = catADCInstanceList[u8Instance];
  
  /* If we have a correct instance */
  if (N_ELEMENTS(catADCInstanceList) > u8Instance)
  {
    /* If we have valid data */
    if (TRUE == tMyADC->CDR[u8Channel].B.VALID)
    {
      /* Copy the data to the pointer */
      *pu16ADCResult = (uint16_t) tMyADC->CDR[u8Channel].B.CDATA;
    }
    else
    {
      /* We don't have valid data if we're here */
      u8Status = ADC_ERR_INVALID_RESULT;
    }
  }
  else
  {
    /* We are pointing somewhere else. Don't continue */
    u8Status = ADC_ERR_BAD_INSTANCE;
  }
  
  return (u8Status);
}

/*
 ******************************************************************************
 * u8fnADCStatus
 ******************************************************************************
 */
uint8_t u8fnADCStatus(uint8_t u8Instance)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  u8Status = (uint8_t)(catADCInstanceList[u8Instance]->MSR.B.ADCSTATUS);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnADNormalConversionEnable
 ******************************************************************************
 */
uint8_t u8fnADCNormalConversionEnable(uint8_t u8Instance, uint8_t u8Enable)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init Local Variables */
  u8Status = CLEAR;
  
  /* Continue only if pointer is valid */
  if (N_ELEMENTS(catADCInstanceList) > u8Instance)
  {
    catADCInstanceList[u8Instance]->MCR.B.NSTART = (CLEAR < u8Enable);
  }
  else
  {
    /* We had an error */
    u8Status = ADC_ERR_BAD_INSTANCE;
  }
  return (u8Status);
}
 /*
  ******************************************************************************
  * vfnADCEoCIsr
  ******************************************************************************
  */
 static void vfnADCEoCIsr(uint8_t u8Instance)
 {
   /* Declare local variables */
   ADC_t tMyADC;
   vuint8_t u8Counter;
   uint16_t u16ChannelsToRead;
      
   /* Init Local Variables */
   tMyADC = catADCInstanceList[u8Instance];
   u16ChannelsToRead = gau16ADCChToRead[u8Instance];
   
   switch (tMyADC->ISR.R)
   {
     case (ADC_ISR_EOCTU_MASK):
     {
        /* Something*/
        break;
     }
     case (ADC_ISR_JEOC_MASK):
     {
       /* Something */
       u8Counter = 1;
       break;
     }
     case (ADC_ISR_JECH_MASK):
     {
       /* Something */
       u8Counter = 8;
       break;
     }
     case (ADC_ISR_EOC_MASK):
     {
       u8Counter = 3;
       break;
     }
     case (ADC_ISR_EOC_MASK | ADC_ISR_ECH_MASK):
     {
       /* Clear interrupt flag for EOC */
       tMyADC->ISR.R |= ADC_ISR_EOC_MASK;
       /* Trickle down to the ECH case */
     }
     case (ADC_ISR_ECH_MASK):
     {
       for (u8Counter = CLEAR; u8Counter < BITS_IN_16; u8Counter++)
       {
         if(BIT0 & u16ChannelsToRead)
         {
           
           *gpu16ADCResults[(u8Instance * (ADC_CH_MAX + 1u)) + u8Counter] = (uint16_t)tMyADC->CDR[u8Counter].B.CDATA;
           
         }
         else
         {
           /* Don't do anything */
         }
         u16ChannelsToRead >>= 1u;
       }
       tMyADC->ISR.R |= ADC_ISR_ECH_MASK;
       break;
    }
    default:
    {
      /* Nothing happened */
    }
  };
    
  return;
}
/*
 ******************************************************************************
 * vfnADC0EoCIsr
 ******************************************************************************
 */
void vfnADC0EoCIsr(void)
{
  vfnADCEoCIsr(ADC_MODULE_0);
  return;
}
/*
 ******************************************************************************
 * vfnADC1EoCIsr
 ******************************************************************************
 */
void vfnADC1EoCIsr(void)
{
  vfnADCEoCIsr(ADC_MODULE_1);
  return;
}
/*
 ******************************************************************************
 * vfnADCErrIsr
 ******************************************************************************
 */
static void vfnADCErrIsr(uint8_t u8Instance)
{
  (void)u8Instance;
  return;
}
/*
 ******************************************************************************
 * vfnADC0ErrIsr
 ******************************************************************************
 */
void vfnADC0ErrIsr(void)
{
  vfnADCErrIsr(ADC_MODULE_0);
  return;
}
/*
 ******************************************************************************
 * vfnADC1ErrIsr
 ******************************************************************************
 */
void vfnADC1ErrIsr(void)
{
  vfnADCErrIsr(ADC_MODULE_1);
  return;
}
/*
 ******************************************************************************
 * vfnADCWatchDogIsr
 ******************************************************************************
 */
static void vfnADCWatchDogIsr(uint8_t u8Instance)
{
  (void)u8Instance;
  return;
}
/*
 ******************************************************************************
 * vfnADC0WatchDogIsr
 ******************************************************************************
 */
void vfnADC0WatchDogIsr(void)
{
  vfnADCWatchDogIsr(ADC_MODULE_0);
  return;
}
/*
 ******************************************************************************
 * vfnADC1EoCTUIsr
 ******************************************************************************
 */
void vfnADC1WatchDogIsr(void)
{
  vfnADCWatchDogIsr(ADC_MODULE_1);
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */